class WordSegmenter {
  constructor() {
    // 初始化词典，包含常见中文词汇
    this.dictionary = new Set([
      '我', '你', '他', '她', '它', '我们', '你们', '他们',
      '的', '是', '在', '有', '和', '就', '不', '人', '都',
      '一', '一个', '上', '也', '很', '到', '说', '要', '去',
      '会', '着', '没有', '看', '好', '自己', '这', '学习',
      '人工智能', '计算机', '程序', '开发', '技术', '数据',
      '分析', '中国', '北京', '上海', '城市', '公司', '工作'
    ]);
    
    // 最大匹配长度
    this.maxWordLength = 5;
  }
  
  /**
   * 添加词汇到词典
   * @param {string|string[]} words 要添加的词汇或词汇数组
   */
  addWords(words) {
    if (Array.isArray(words)) {
      words.forEach(word => this.dictionary.add(word));
    } else {
      this.dictionary.add(words);
    }
  }
  
  /**
   * 从词典中移除词汇
   * @param {string|string[]} words 要移除的词汇或词汇数组
   */
  removeWords(words) {
    if (Array.isArray(words)) {
      words.forEach(word => this.dictionary.delete(word));
    } else {
      this.dictionary.delete(words);
    }
  }
  
  /**
   * 正向最大匹配分词算法
   * @param {string} text 要分词的文本
   * @returns {string[]} 分词结果数组
   */
  segmentForward(text) {
    const result = [];
    let index = 0;
    const textLength = text.length;
    
    while (index < textLength) {
      // 确定当前尝试的最大长度
      let maxTryLength = Math.min(this.maxWordLength, textLength - index);
      let found = false;
      
      // 从最大长度开始尝试匹配
      for (let len = maxTryLength; len > 0; len--) {
        const word = text.substr(index, len);
        if (this.dictionary.has(word)) {
          result.push(word);
          index += len;
          found = true;
          break;
        }
      }
      
      // 如果没有找到匹配的词，将单个字符作为词
      if (!found) {
        result.push(text.substr(index, 1));
        index++;
      }
    }
    
    return result;
  }
  
  /**
   * 反向最大匹配分词算法
   * @param {string} text 要分词的文本
   * @returns {string[]} 分词结果数组
   */
  segmentBackward(text) {
    const result = [];
    let index = text.length;
    
    while (index > 0) {
      // 确定当前尝试的最大长度
      let maxTryLength = Math.min(this.maxWordLength, index);
      let found = false;
      
      // 从最大长度开始尝试匹配
      for (let len = maxTryLength; len > 0; len--) {
        const start = index - len;
        const word = text.substr(start, len);
        if (this.dictionary.has(word)) {
          result.unshift(word);
          index = start;
          found = true;
          break;
        }
      }
      
      // 如果没有找到匹配的词，将单个字符作为词
      if (!found) {
        index--;
        result.unshift(text.substr(index, 1));
      }
    }
    
    return result;
  }
  
  /**
   * 简单的双向最大匹配分词算法
   * @param {string} text 要分词的文本
   * @returns {string[]} 分词结果数组
   */
  segment(text) {
    const forwardResult = this.segmentForward(text);
    const backwardResult = this.segmentBackward(text);
    
    // 选择分词数量较少的结果
    if (forwardResult.length < backwardResult.length) {
      return forwardResult;
    } else if (backwardResult.length < forwardResult.length) {
      return backwardResult;
    }
    
    // 如果分词数量相同，选择单字较少的结果
    const countSingleForward = forwardResult.filter(word => word.length === 1).length;
    const countSingleBackward = backwardResult.filter(word => word.length === 1).length;
    
    return countSingleForward <= countSingleBackward ? forwardResult : backwardResult;
  }
  
  /**
   * 分词并返回带分隔符的字符串
   * @param {string} text 要分词的文本
   * @param {string} separator 分隔符，默认为空格
   * @returns {string} 分词后的字符串
   */
  segmentToString(text, separator = ' ') {
    return this.segment(text).join(separator);
  }
  
  /**
   * 统计分词结果中每个词的出现频率
   * @param {string} text 要分析的文本
   * @returns {Object} 词频统计对象
   */
  getWordFrequency(text) {
    const words = this.segment(text);
    const frequency = {};
    
    words.forEach(word => {
      if (frequency[word]) {
        frequency[word]++;
      } else {
        frequency[word] = 1;
      }
    });
    
    return frequency;
  }
}

// 使用示例
if (typeof module !== 'undefined' && module.exports) {
  module.exports = WordSegmenter;
} else {
  // 浏览器环境下的示例
  window.WordSegmenter = WordSegmenter;
  
  // 演示代码
  document.addEventListener('DOMContentLoaded', () => {
    const segmenter = new WordSegmenter();
    segmenter.addWords(['分词', '服务', 'JavaScript', '演示']);
    
    const testText = '这是一个JavaScript分词服务的演示，用于展示中文分词功能。';
    const result = segmenter.segment(testText);
    const resultStr = segmenter.segmentToString(testText);
    const frequency = segmenter.getWordFrequency(testText);
    
    console.log('分词结果数组:', result);
    console.log('分词结果字符串:', resultStr);
    console.log('词频统计:', frequency);
  });
}
